#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
示例插件 - 展示如何扩展迁移工具功能
"""

from typing import List, Dict, Any, Optional
import logging

logger = logging.getLogger(__name__)


class ExamplePlugin:
    """
    示例插件类
    
    这个插件展示了如何：
    1. 添加自定义数据类型转换
    2. 实现自定义验证规则
    3. 提供自定义报告格式
    """
    
    def __init__(self):
        self.name = "example_plugin"
        self.version = "1.0.0"
        self.description = "示例插件，展示插件系统的使用方法"
        
    def get_info(self) -> Dict[str, Any]:
        """获取插件信息"""
        return {
            'name': self.name,
            'version': self.version,
            'description': self.description,
            'hooks': [
                'pre_parse',
                'post_parse', 
                'pre_convert',
                'post_convert',
                'custom_validation',
                'custom_report'
            ]
        }
    
    def pre_parse(self, sql_content: str) -> str:
        """
        解析前钩子 - 在SQL解析之前调用
        
        Args:
            sql_content: 原始SQL内容
            
        Returns:
            处理后的SQL内容
        """
        logger.info(f"[{self.name}] 执行解析前处理")
        
        # 示例：移除特定的MySQL注释
        lines = sql_content.split('\n')
        filtered_lines = []
        
        for line in lines:
            # 移除包含特定标记的注释
            if not (line.strip().startswith('--') and 'MYSQL_SPECIFIC' in line):
                filtered_lines.append(line)
        
        return '\n'.join(filtered_lines)
    
    def post_parse(self, parsed_statements: List[Any]) -> List[Any]:
        """
        解析后钩子 - 在SQL解析之后调用
        
        Args:
            parsed_statements: 解析后的语句列表
            
        Returns:
            处理后的语句列表
        """
        logger.info(f"[{self.name}] 执行解析后处理，处理了{len(parsed_statements)}个语句")
        
        # 示例：添加统计信息
        for stmt in parsed_statements:
            if hasattr(stmt, 'metadata'):
                stmt.metadata = getattr(stmt, 'metadata', {})
                stmt.metadata['processed_by'] = self.name
        
        return parsed_statements
    
    def pre_convert(self, statements: List[Any]) -> List[Any]:
        """
        转换前钩子 - 在语法转换之前调用
        
        Args:
            statements: 待转换的语句列表
            
        Returns:
            处理后的语句列表
        """
        logger.info(f"[{self.name}] 执行转换前处理")
        
        # 示例：为特定类型的语句添加标记
        for stmt in statements:
            if hasattr(stmt, 'statement_type') and 'CREATE' in str(stmt.statement_type):
                stmt.plugin_flags = getattr(stmt, 'plugin_flags', [])
                stmt.plugin_flags.append('example_processed')
        
        return statements
    
    def post_convert(self, converted_statements: List[Any]) -> List[Any]:
        """
        转换后钩子 - 在语法转换之后调用
        
        Args:
            converted_statements: 转换后的语句列表
            
        Returns:
            处理后的语句列表
        """
        logger.info(f"[{self.name}] 执行转换后处理")
        
        # 示例：验证转换结果
        for stmt in converted_statements:
            if hasattr(stmt, 'original_sql') and 'AUTO_INCREMENT' in stmt.original_sql:
                # 确保AUTO_INCREMENT被正确转换
                if 'unique_rowid()' not in stmt.original_sql:
                    logger.warning(f"[{self.name}] AUTO_INCREMENT可能未正确转换")
        
        return converted_statements
    
    def custom_validation(self, original_statements: List[Any], 
                         converted_statements: List[Any]) -> List[Dict[str, Any]]:
        """
        自定义验证规则
        
        Args:
            original_statements: 原始语句列表
            converted_statements: 转换后语句列表
            
        Returns:
            验证结果列表
        """
        logger.info(f"[{self.name}] 执行自定义验证")
        
        validation_results = []
        
        # 示例验证：检查表数量是否一致
        original_tables = sum(1 for stmt in original_statements 
                            if hasattr(stmt, 'statement_type') and 'CREATE_TABLE' in str(stmt.statement_type))
        converted_tables = sum(1 for stmt in converted_statements 
                             if hasattr(stmt, 'statement_type') and 'CREATE_TABLE' in str(stmt.statement_type))
        
        if original_tables != converted_tables:
            validation_results.append({
                'rule': 'table_count_consistency',
                'status': 'failed',
                'message': f'表数量不一致：原始{original_tables}个，转换后{converted_tables}个',
                'severity': 'error',
                'plugin': self.name
            })
        else:
            validation_results.append({
                'rule': 'table_count_consistency',
                'status': 'passed',
                'message': f'表数量一致：{original_tables}个',
                'severity': 'info',
                'plugin': self.name
            })
        
        return validation_results
    
    def custom_report(self, migration_data: Dict[str, Any]) -> Dict[str, Any]:
        """
        生成自定义报告部分
        
        Args:
            migration_data: 迁移数据
            
        Returns:
            报告数据
        """
        logger.info(f"[{self.name}] 生成自定义报告")
        
        report = {
            'plugin_name': self.name,
            'plugin_version': self.version,
            'report_sections': {
                'summary': {
                    'title': '插件处理摘要',
                    'content': f'示例插件已处理迁移任务'
                },
                'recommendations': {
                    'title': '插件建议',
                    'content': [
                        '建议在生产环境中禁用示例插件',
                        '可以基于此插件开发自定义功能',
                        '插件系统支持热插拔'
                    ]
                }
            }
        }
        
        return report


class CustomDataTypePlugin:
    """
    自定义数据类型转换插件
    """
    
    def __init__(self):
        self.name = "custom_datatype_plugin"
        self.version = "1.0.0"
        
    def get_custom_type_mappings(self) -> Dict[str, str]:
        """
        提供自定义数据类型映射
        
        Returns:
            数据类型映射字典
        """
        return {
            # MySQL -> KWDB 自定义映射
            'GEOMETRY': 'STRING',  # 几何类型转为字符串
            'POINT': 'STRING',     # 点类型转为字符串
            'POLYGON': 'STRING',   # 多边形类型转为字符串
            'LINESTRING': 'STRING', # 线类型转为字符串
            'JSON': 'JSONB',       # JSON类型转为JSONB
            'YEAR': 'INT',         # 年份类型转为整数
        }
    
    def convert_custom_type(self, mysql_type: str, length: Optional[str] = None) -> str:
        """
        转换自定义数据类型
        
        Args:
            mysql_type: MySQL数据类型
            length: 类型长度（如果有）
            
        Returns:
            KWDB数据类型
        """
        mappings = self.get_custom_type_mappings()
        
        if mysql_type.upper() in mappings:
            kwdb_type = mappings[mysql_type.upper()]
            
            # 对于需要长度的类型，添加长度信息
            if kwdb_type == 'STRING' and length:
                return f'STRING({length})'
            
            return kwdb_type
        
        return mysql_type  # 如果没有映射，返回原类型


# 插件注册函数
def register_plugins():
    """
    注册插件的函数
    这个函数会被插件管理器调用
    """
    return [
        ExamplePlugin(),
        CustomDataTypePlugin()
    ]


if __name__ == '__main__':
    # 测试插件功能
    plugin = ExamplePlugin()
    print(f"插件信息: {plugin.get_info()}")
    
    # 测试数据类型插件
    datatype_plugin = CustomDataTypePlugin()
    print(f"自定义类型映射: {datatype_plugin.get_custom_type_mappings()}")
    print(f"GEOMETRY转换: {datatype_plugin.convert_custom_type('GEOMETRY')}")
    print(f"JSON转换: {datatype_plugin.convert_custom_type('JSON')}")
